import axios from 'axios';
import router from '../router/index';

const API = axios.create({
    timeout: 65000 // request timeout
});

API.Axios = axios;
API.all = axios.all;
API.spread = axios.spread;

let pending = []; // 用于存储每个 ajax 请求的取消函数和 ajax 标识
let cancelToken = axios.CancelToken;

API.removePending = (ever) => {
    for (let p in pending) {
        if (pending[p].u === ever.url + '&' + ever.method) { // 当当前请求在数组中存在时执行函数体
            pending[p].f(); // 执行取消操作
            pending.splice(p, 1); // 把这条记录从数组中移除
        }
    }
};

// 请求拦截器
// 设置 header
API.interceptors.request.use(config => {
        // 开发环境下
        // 设置特定 mock 代理请求头
        if (process.env.NODE_ENV === 'development') {
            let mockHeader = localStorage.dms_dev_host;
            if (mockHeader) {
                config.headers['X-Mock-Proxy'] = mockHeader;
            }
        }

        API.removePending(config); //在一个ajax发送前执行一下取消操作
        config.cancelToken = new cancelToken((c) => {
            // 这里的ajax标识我是用请求地址&请求方式拼接的字符串，当然你可以选择其他的一些方式
            pending.push({u: config.url + '&' + config.method, f: c});
        });
        // 加个时间戳
        config.requestTime = new Date().getTime();

        // 设置统一 token 请求头
        let token = sessionStorage.token;
        if (token) {
            config.headers.token = token;
        }

        return config;
    }, error => {
        return Promise.reject(error);
    }
);

// 响应拦截器
API.interceptors.response.use(response => {
        API.removePending(response.config);
        // 如果不是成功，那么都抛致错误
        if (response.data && response.data.code !== 0) {
            return Promise.reject(response);
        }
        return response;
    }, error => {
        if (error.response) {
            // 有 response 属性，说明有服务器响应
            const {status, data} = error.response;

            // token 过期处理
            if ([401, 403].includes(status)) {
                console.log('token 过期');
                return Promise.reject(router.push({path: '/login'}));
            }
            return Promise.reject(data);
        }
        return Promise.reject();
    }
);

API.formatParams = function (params, method) {
    let result = {
        params: {},
        data: {}
    }, keys = params ? Object.getOwnPropertyNames(params) : [];

    if (keys.length === 0) {
        return result;
    }

    if (keys.includes('params') || keys.includes('data')) {
        return Object.assign(result, params);
    }

    if (['get'].includes(method)) {
        Object.assign(result.params, params);
    } else {
        Object.assign(result.data, params);
    }
    return result;
};

/*
* 抽取通用方法ajax
*/
const ajax = (url, method, params) => {
    let config = {url, method};
    Object.assign(config, API.formatParams(params, method));
    return API(config);
};

API.ajax = ajax;

// let getBase = url => {
//     let href = url || location.href;
//     let index = href.indexOf('#');
//     if (index > -1) index--;
//     else index = href.lastIndexOf('/');
//     return href.slice(0, index);
// };

const SERVER_BASE = '/api/v1';

/**
 * 登录
 */
API.login = user => {
    return new Promise((resolve, reject) => {
        ajax('/login', 'post', user)
            .then(resp => {
                let token = resp.data.data.token;
                let id = token ? token.split(':')[1] : null;
                // TODO 登录接口
                sessionStorage.setItem('token', token);
                sessionStorage.setItem('userId', id);
                resolve(true);
            })
            .catch(err => {
                reject(err);
            });
    });
};

/**
 * 登出
 * @param token 秘钥
 */
API.logout = token => {
    return ajax('/logout', 'get', {token});
};

// 用户管理
API.users = {
    // 添加账户（只有超级管理员才能添加账户）
    add(user) {
        return ajax(`${SERVER_BASE}/users/`, 'post', user);
    },

    // 修改账户（超级管理员可以修改所有账户信息，普通账户只能修改自己的账号信息）
    update(user) {
        return ajax(`${SERVER_BASE}/users/${user.id}/`, 'patch', user);
    },

    // 单删除账户（超级管理员可以删除非他自己的所有账户信息，删除的同时会冻结）
    del(id) {
        return ajax(`${SERVER_BASE}/users/${id}/`, 'delete');
    },

    // 查看账户信息
    get(id) {
        return ajax(`${SERVER_BASE}/users/${id}/`, 'get');
    },

    // 查看所有用户
    getAll() {
        return ajax(`${SERVER_BASE}/users/`, 'get');
    },

    // 批量冻结账户（只有超级管理员才可冻结账户）
    freeze(idList) {
        return ajax(`${SERVER_BASE}/users/multiple_frozen/`, 'post', {user_ids: idList});
    },

    // 批量激活账户（只有超级管理员才可激活账户）
    activate(idList) {
        return ajax(`${SERVER_BASE}/users/multiple_active/`, 'post', {user_ids: idList});
    }
};

// 部门管理
API.department = {
    // 添加部门
    add(name) {
        return ajax(`${SERVER_BASE}/department/`, 'post', {name});
    },

    // 查看部门
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/department/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/department/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/department/`, 'get');
    },

    // 修改部门
    update(id, name) {
        return ajax(`${SERVER_BASE}/department/${id}/`, 'patch', {name});
    },

    // 删除部门（禁用：删除部门，会同时删除关联的职位数据，及应聘者投递的职位信息）
    del(id) {
        return ajax(`${SERVER_BASE}/department/${id}/`, 'delete');
    }
};

// 职位发布渠道管理
API.release = {
    // 添加职位发布渠道
    add(name) {
        return ajax(`${SERVER_BASE}/release/`, 'post', {name});
    },

    // 查看职位发布渠道
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/release/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/release/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/release/`, 'get');
    },

    // 修改职位发布渠道
    update(id, name) {
        return ajax(`${SERVER_BASE}/release/${id}/`, 'patch', {name});
    },

    // 删除职位发布渠道
    del(id) {
        return ajax(`${SERVER_BASE}/release/${id}/`, 'delete');
    }
};

// 简历接收渠道管理
API.receive = {
    // 添加简历接收渠道管理
    add(name) {
        return ajax(`${SERVER_BASE}/receive/`, 'post', {name});
    },

    // 查看简历接收渠道管理
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/receive/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/receive/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/receive/`, 'get');
    },

    // 修改简历接收渠道管理
    update(id, name) {
        return ajax(`${SERVER_BASE}/receive/${id}/`, 'patch', {name});
    },

    // 删除简历接收渠道管理
    del(id) {
        return ajax(`${SERVER_BASE}/receive/${id}/`, 'delete');
    }
};

// 人才库管理
API.warehouse = {
    // 添加人才库
    add(warehouse) {
        return ajax(`${SERVER_BASE}/warehouse/`, 'post', warehouse);
    },

    // 查看人才库
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/warehouse/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/warehouse/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/warehouse/`, 'get');
    },

    // 修改人才库
    update(id, warehouse) {
        return ajax(`${SERVER_BASE}/warehouse/${id}/`, 'patch', warehouse);
    },

    // 删除人才库
    del(id) {
        return ajax(`${SERVER_BASE}/warehouse/${id}/`, 'delete');
    }
};

// 人才标签管理
API.labels = {
    // 添加人才标签
    add(name) {
        return ajax(`${SERVER_BASE}/labels/`, 'post', {name});
    },

    // 查看人才标签
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/labels/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/labels/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/labels/`, 'get');
    },

    // 修改人才标签
    update(id, name) {
        return ajax(`${SERVER_BASE}/labels/${id}/`, 'patch', {name});
    },

    // 删除人才标签
    del(id) {
        return ajax(`${SERVER_BASE}/labels/${id}/`, 'delete');
    }
};

// 招聘流程管理
API.flow = {
    // 添加招聘流程
    add(title) {
        return ajax(`${SERVER_BASE}/flow/`, 'post', {title});
    },

    // 查看招聘流程
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/flow/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/flow/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/flow/`, 'get');
    },

    // 修改招聘流程
    update(id, title) {
        return ajax(`${SERVER_BASE}/flow/${id}/`, 'patch', {title});
    },

    // 删除招聘流程
    del(id) {
        return ajax(`${SERVER_BASE}/flow/${id}/`, 'delete');
    }
};

// 职位详情管理
API.jobs = {
    // 添加职位名称
    add(choices) {
        return ajax(`${SERVER_BASE}/jobs/`, 'post', choices);
    },

    // 修改职位名称
    update(id, choices) {
        return ajax(`${SERVER_BASE}/jobs/${id}/`, 'patch', choices);
    },

    // 删除职位信息
    del(id) {
        return ajax(`${SERVER_BASE}/jobs/${id}/`, 'delete');
    },

    // 查看职位信息
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/jobs/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/jobs/`, 'get');
        }
    },

    getAll(params) {
        return ajax(`${SERVER_BASE}/jobs/`, 'get', params);
    },

    // 批量删除职位信息
    delAll(job_ids) {
        return ajax(`${SERVER_BASE}/jobs/multiple_delete/`, 'delete', {job_ids});
    },

    // 对职位进行分页，限制每页显示的职位数
    page(limit, offset) {
        return ajax(`${SERVER_BASE}/jobs/`, 'get', {limit, offset});
    },

    // 对职位进行过滤（目前只有创建时间、工作地点、部门、招聘类型）
    filter(condition) {
        return ajax(`${SERVER_BASE}/jobs/`, 'get', condition);
    },

    // 对职位进行排序（目前只有id、工资下限、创建时间）
    order(ordering) {
        return ajax(`${SERVER_BASE}/jobs/`, 'get', {ordering});
    },

    // 对职位进行模糊搜索（目前只有职位名称、工作地点、部门、招聘类型）
    search(search) {
        return ajax(`${SERVER_BASE}/jobs/`, 'get', {search});
    }
};

// 跟进记录管理
API.record = {
    // 添加跟进记录
    add(record) {
        return ajax(`${SERVER_BASE}/record/`, 'post', record);
    },

    // 修改跟进记录
    update(id, newRecord) {
        return ajax(`${SERVER_BASE}/record/${id}/`, 'patch', newRecord);
    },

    // 删除跟进记录
    del(id) {
        return ajax(`${SERVER_BASE}/record/${id}/`, 'delete');
    },

    // 查看跟进记录
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/record/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/record/`, 'get');
        }
    },

    getAll() {
        return ajax(`${SERVER_BASE}/record/`, 'get');
    },

    // 批量导出应聘者列表
    export(user_list) {
        return ajax(`${SERVER_BASE}/export/`, 'post', {user_list});
    }
};

// 邮件发送模块
API.email = {
    // 发送邮件
    send(msg) {
        return ajax(`${SERVER_BASE}/send_info/`, 'post', msg);
    },

    // 查看已发送的邮件状态列表
    get() {
        return ajax(`${SERVER_BASE}/send_info/`, 'get');
    }
};

// 应聘者管理
API.applicantScreen = {
    // 查看应聘者列表
    get(id) {
        if (id) {
            return ajax(`${SERVER_BASE}/applicant_screen/${id}/`, 'get');
        } else {
            return ajax(`${SERVER_BASE}/applicant_screen/`, 'get');
        }
    },

    getAll(params) {
        return ajax(`${SERVER_BASE}/applicant_screen/`, 'get', params);
    },

    // 修改应聘者列表
    update(id, newApplicant) {
        return ajax(`${SERVER_BASE}/applicant_screen/${id}/`, 'patch', newApplicant);
    },

    // 批量修改应聘者状态（status）
    updateAll(applicant_ids, status) {
        return ajax(
            `${SERVER_BASE}/applicant_screen/multiple_status/`,
            'post',
            {applicant_ids, status}
        );
    },

    // 批量添加到人才库（warehouse）
    addAll(applicant_ids, warehouse) {
        return ajax(
            `${SERVER_BASE}/applicant_screen/multiple_status/`,
            'post',
            {applicant_ids, warehouse}
        );
    }
};

// 应聘者登记
API.applicantRegister = {
    // 登记
    register(applicant) {
        return new Promise((resolve, reject) => {
            ajax(`${SERVER_BASE}/applicant_register/`, 'post', applicant)
                .then(resp => {
                    let token = resp.data.data.TOKEN;
                    let id = token ? token.split(':')[1] : null;
                    sessionStorage.setItem('token', token);
                    sessionStorage.setItem('userId', id);
                    resolve();
                }, err => {
                    reject(err);
                });
        });
    },

    // 创建微简历
    createMicroResume(microResume) {
        return ajax(`${SERVER_BASE}/micro_resume/`, 'post', microResume);
    },

    // 获取微简历
    getMicroResume() {
        return ajax(`${SERVER_BASE}/micro_resume/`, 'get');
    },

    // 获取简历文件下载地址
    getResumeFileUrl() {
        return ajax(`${SERVER_BASE}/resume_storage/`, 'get');
    },

    // 上传简历文件
    resumeStorage(params) {
        let config = {
            headers: {
                'Content-Type': 'multipart/form-data'
            }
        };
        if (process.env.NODE_ENV === 'development') {
            let mockHeader = localStorage.dms_dev_host;
            if (mockHeader) {
                config.headers['X-Mock-Proxy'] = mockHeader;
            }
            let token = sessionStorage.token;
            if (token) {
                config.headers.token = token;
            }
        }
        return new Promise((resolve, reject) => {
            axios.post(`${SERVER_BASE}/resume_storage/`, params, config)
                .then(resp => {
                    resolve(resp);
                }, err => {
                    reject(err);
                });
        });
    },

    // 发送验证邮件（应聘者二次进入系统）
    getVerifyCode(emails) {
        return ajax(`${SERVER_BASE}/applicant_send/`, 'post', {emails});
    },

    // 验证验证码（应聘者二次进入系统）
    applicantVerification(params) {
        return new Promise((resolve, reject) => {
            ajax(`${SERVER_BASE}/applicant_verification/`, 'post', params)
                .then(resp => {
                    let token = resp.data.data.TOKEN;
                    if (token) {
                        sessionStorage.setItem('token', token);
                        resolve(true);
                    } else {
                        sessionStorage.removeItem('token');
                    }
                }, err => {
                    reject(err);
                });
        });
        // return ajax(`${SERVER_BASE}/applicant_verification/`, 'post', params);
    },

    // 应聘者退出系统
    applicantLogout() {
        return ajax(`${SERVER_BASE}/applicant_logout/`, 'get');
    }
};

// 主页面板
API.homePanel = () => {
    return ajax(
        `${SERVER_BASE}/home_panel/`,
        'get'
    );
};

export default API;
